#include "customfilelistwidget.h"
#include "customfilebrowser.h"
#include "customfileitem.h"
#include <QDebug>
#include <QApplication>
#include <QTimer>
#include <QScrollBar>
#include <algorithm>
CustomFileListWidget::CustomFileListWidget(CustomFileBrowser* parent)
    : QScrollArea(parent)
    , m_parentBrowser(parent)
    , m_contentWidget(nullptr)
    , m_layout(nullptr)
    , m_virtualManager(new VirtualListManager(this))  // 【新增】虚拟化管理器
    , m_currentIndex(-1)
    , m_dropIndicatorIndex(-1)
    , m_isDragInProgress(false)
    , m_dragContext(new DragContext(this))
{
    setupUI();
    connectDragContext();
    
    // 【新增】初始化item池
    initializeItemPool();
    
    qDebug() << "[虚拟化] CustomFileListWidget初始化完成，池大小:" << m_itemPool.size();
}

CustomFileListWidget::~CustomFileListWidget()
{
    // === 虚拟化架构：析构简化版（item池统一清理）===
    
    qDebug() << "[虚拟化] 开始析构CustomFileListWidget，池大小:" << m_itemPool.size();
    
    // 1. 立即停止接收任何新事件
    setUpdatesEnabled(false);
    setEnabled(false);
    
    // 2. 清理所有待处理的事件（所有层级）
    QCoreApplication::removePostedEvents(this);
    if (viewport()) {
        QCoreApplication::removePostedEvents(viewport());
    }
    if (m_contentWidget) {
        QCoreApplication::removePostedEvents(m_contentWidget);
    }
    
    // 3. 清理item池（替代旧的m_items清理）
    for (CustomFileItem* item : m_itemPool) {
        if (item) {
            // 移除item的所有待处理事件
            QCoreApplication::removePostedEvents(item);
            // 立即隐藏和禁用
            item->hide();
            item->setEnabled(false);
            item->setAttribute(Qt::WA_TransparentForMouseEvents, true);
            item->setMouseTracking(false);
            // 断开所有信号连接
            disconnect(item, nullptr, this, nullptr);
            disconnect(item, nullptr, nullptr, nullptr);
            // 从布局中移除
            if (m_layout) {
                m_layout->removeWidget(item);
            }
            // 立即删除
            delete item;
        }
    }
    m_itemPool.clear();
    m_items.clear();  // 清理旧列表（兼容期）
    
    // 4. 清理虚拟化管理器的绑定
    if (m_virtualManager) {
        m_virtualManager->clearAllBindings();
    }
    
    // 5. 处理一次事件队列，确保清理完成
    QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
    
    qDebug() << "[虚拟化] CustomFileListWidget析构完成";
}

void CustomFileListWidget::connectDragContext()
{
    // 连接拖拽上下文信号
    connect(m_dragContext, &DragContext::dragStarted, this, [this](const QList<int>& sourceIndices) {
    });
    connect(m_dragContext, &DragContext::dragCompleted, this, [this](const QList<int>& newPositions) {
        // 在刷新UI之前先重置拖拽状态，确保refreshUI不会被跳过
        m_isDragInProgress = false;
        // 使用拖拽上下文的新位置信息进行UI刷新
        refreshUI(newPositions);
    });
    connect(m_dragContext, &DragContext::dragCancelled, this, [this]() {
        m_isDragInProgress = false;
        hideDropIndicator();
    });
}
void CustomFileListWidget::setupUI()
{
    // 创建内容区域
    m_contentWidget = new QWidget(this);
    m_layout = new QVBoxLayout(m_contentWidget);
    m_layout->setContentsMargins(0, 0, 0, 0);
    m_layout->setSpacing(2);  // 初始间距2px（会根据item高度动态调整）
    // 设置滚动区域属性
    setWidget(m_contentWidget);
    setWidgetResizable(true);
    setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
    setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
    // 设置尺寸策略，允许水平和垂直方向的调整
    setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    // 设置内容区域的尺寸策略
    m_contentWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
    // 启用拖拽支持
    setAcceptDrops(true);
    
    // === 关键修复：安装事件过滤器，保护刷新期间的事件 ===
    installEventFilter(this);
    if (viewport()) {
        viewport()->installEventFilter(this);
    }
    if (m_contentWidget) {
        m_contentWidget->installEventFilter(this);
    }
    
    // 设置样式，使用微妙的层次感背景色
    setStyleSheet(
        "QScrollArea {"
        "    border: none;"
        "    background-color: #f0f0f0;"
        "}"
        "QScrollBar:vertical {"
        "    background: palette(base);"
        "    width: 12px;"
        "    border-radius: 6px;"
        "}"
        "QScrollBar::handle:vertical {"
        "    background: palette(mid);"
        "    border-radius: 6px;"
        "    min-height: 20px;"
        "}"
        "QScrollBar::handle:vertical:hover {"
        "    background: palette(dark);"
        "}"
    );
}
void CustomFileListWidget::refreshUI(const QList<int>& draggedNewPositions)
{
    // === 虚拟化架构：refreshUI已废弃，改用rebindAllItems ===
    qDebug() << "[虚拟化] refreshUI被调用（兼容模式），转发到rebindAllItems";
    
    // 检查拖拽状态 - 正常情况下不应该还在拖拽中
    if (m_isDragInProgress) {
        return;
    }
    
    // 保存当前选择状态，用于拖拽排序后恢复
    int savedCurrentIndex = m_currentIndex;
    QSet<int> savedSelectedIndices = m_selectedIndices;
    
    // === 【关键】虚拟化架构：重新绑定item，不删除 ===
    rebindAllItems();
    
    // 重置选择状态
    m_selectedIndices.clear();
    m_currentIndex = -1;
    
    // 恢复选择状态，使用拖拽新位置信息
    if (m_parentBrowser && m_parentBrowser->getFileCount() > 0) {
        if (!draggedNewPositions.isEmpty()) {
            // === Martin Fowler重构：Extract Method - 拖拽状态恢复 ===
            restoreSelectionAfterDrag(draggedNewPositions);
        } else {
            // === Martin Fowler重构：Extract Method - 正常状态恢复 ===
            restoreSelectionAfterRefreshVirtualized(savedCurrentIndex, savedSelectedIndices);
        }
    }
    
    qDebug() << "[虚拟化] refreshUI完成，文件数:" << m_parentBrowser->getFileCount();
}

// === 虚拟化版本的选择状态恢复 ===
void CustomFileListWidget::restoreSelectionAfterRefreshVirtualized(int savedCurrentIndex, const QSet<int>& savedSelectedIndices)
{
    // 虚拟化架构：通过重新绑定item来更新选择状态
    if (savedCurrentIndex >= 0 && savedCurrentIndex < m_parentBrowser->getFileCount()) {
        // 恢复选择状态
        m_currentIndex = savedCurrentIndex;
        for (int index : savedSelectedIndices) {
            if (index >= 0 && index < m_parentBrowser->getFileCount()) {
                m_selectedIndices.insert(index);
            }
        }
        
        // 重新绑定以应用选择状态
        rebindVisibleItems();
        
        // 发送信号
        emit selectionChanged(m_selectedIndices.values());
    } else {
        if (m_parentBrowser->getFileCount() > 0) {
            // 保存的选中文件不存在了，选择第一个
            updateSelection(0, false);
        }
    }
}
void CustomFileListWidget::updateSelection(int index, bool emitSignals)
{
    if (!m_parentBrowser || index < 0 || index >= m_parentBrowser->getFileCount()) {
        return;
    }
    // 清除之前的选择
    clearSelection();
    // 设置新选择
    m_selectedIndices.insert(index);
    m_currentIndex = index;
    
    // 【虚拟化】更新UI显示 - 通过重新绑定可见item
    CustomFileItem* item = getItemForFileIndex(index);
    if (item) {
        item->setSelected(true);
    }
    
    // 根据参数决定是否发送信号
    if (emitSignals) {
        emit itemClicked(index);
    }
    emit selectionChanged(m_selectedIndices.values());
}
void CustomFileListWidget::clearSelection()
{
    // 【虚拟化】清除UI选择状态
    for (int index : m_selectedIndices) {
        CustomFileItem* item = getItemForFileIndex(index);
        if (item) {
            item->setSelected(false);
        }
    }
    m_selectedIndices.clear();
    m_currentIndex = -1;
    emit selectionChanged(QList<int>());
}
void CustomFileListWidget::selectAll()
{
    if (!m_parentBrowser) {
        return;
    }
    int fileCount = m_parentBrowser->getFileCount();
    if (fileCount == 0) {
        return;
    }
    // 清除当前选择
    clearSelection();
    // 选中所有文件
    for (int i = 0; i < fileCount; ++i) {
        m_selectedIndices.insert(i);
    }
    
    // 【虚拟化】重新绑定以应用选择状态
    rebindVisibleItems();
    
    // 设置当前索引为第一个文件
    m_currentIndex = 0;
    emit selectionChanged(m_selectedIndices.values());
}
void CustomFileListWidget::updateFileItem(int index)
{
    // === 关键修复：多重边界检查，防止竞态条件 ===
    if (!m_parentBrowser) {
        return;
    }
    
    // 第一次检查：确保索引有效
    int fileCount = m_parentBrowser->getFileCount();
    if (index < 0 || index >= fileCount) {
        return;
    }
    
    // 第二次检查：确保items列表有效
    if (index >= m_items.size()) {
        return;
    }
    
    // 第三次检查：确保item对象存在且可用
    CustomFileItem* item = m_items[index];
    if (!item || !item->isEnabled() || !item->isVisible()) {
        return;
    }
    
    // === 关键修复：在更新前禁用item的事件处理，防止中间状态触发事件 ===
    bool wasEnabled = item->updatesEnabled();
    item->setUpdatesEnabled(false);
    
    try {
        // 获取文件信息（可能在多线程环境下被修改）
        UnifiedFileInfo fileInfo = m_parentBrowser->getFile(index);
        
        // 设置文件信息
        item->setFileInfo(fileInfo);
        
        // 如果启用了自适应模式，更新项目宽度
        if (m_adaptiveMode) {
            if (m_currentWidth > 0) {
                item->setAdaptiveWidth(m_currentWidth);
            } else {
                // 如果自适应模式启用但m_currentWidth为0，立即计算正确的宽度
                updateItemWidths();
                if (m_currentWidth > 0) {
                    item->setAdaptiveWidth(m_currentWidth);
                }
            }
        }
    } catch (...) {
        // 捕获任何异常，防止崩溃
        qWarning() << "updateFileItem: Exception occurred while updating item" << index;
    }
    
    // === 关键修复：恢复更新状态 ===
    if (wasEnabled) {
        item->setUpdatesEnabled(true);
    }
}
void CustomFileListWidget::updateItemWidths()
{
    if (!m_adaptiveMode) {
        return;
    }
    // 获取当前可用宽度（保留5px边距，确保美观）
    int availableWidth = viewport()->width() - 5; // 保留适当的边距
    // 确保宽度在合理范围内
    int itemWidth = qMax(CustomFileItem::MIN_ITEM_WIDTH, availableWidth);
    // 如果宽度没有变化，无需更新
    if (itemWidth == m_currentWidth) {
        return;
    }
    m_currentWidth = itemWidth;
    // 更新所有项目的自适应宽度
    for (CustomFileItem* item : m_items) {
        if (item) {
            item->setAdaptiveWidth(itemWidth);
        }
    }
    // 强制重新布局
    if (m_layout) {
        m_layout->activate();
    }
    update();
}
void CustomFileListWidget::setAdaptiveMode(bool enabled)
{
    if (m_adaptiveMode == enabled) {
        return;
    }
    m_adaptiveMode = enabled;
    if (enabled) {
        // 启用自适应模式时，立即更新宽度
        updateItemWidths();
    } else {
        // 禁用自适应模式时，恢复默认宽度
        m_currentWidth = CustomFileItem::DEFAULT_ITEM_WIDTH;
        for (CustomFileItem* item : m_items) {
            if (item) {
                item->setAdaptiveWidth(CustomFileItem::DEFAULT_ITEM_WIDTH);
            }
        }
    }
}
int CustomFileListWidget::getCurrentSelectedIndex() const
{
    return m_currentIndex;
}
QList<int> CustomFileListWidget::getSelectedIndices() const
{
    return m_selectedIndices.values();
}
void CustomFileListWidget::keyPressEvent(QKeyEvent* event)
{
    if (!m_parentBrowser) {
        QScrollArea::keyPressEvent(event);
        return;
    }
    // 处理键盘导航
    if (event->key() == Qt::Key_Up || event->key() == Qt::Key_Down) {
        int newIndex = m_currentIndex;
        int fileCount = m_parentBrowser->getFileCount();
        if (event->key() == Qt::Key_Up && newIndex > 0) {
            newIndex--;
        } else if (event->key() == Qt::Key_Down && newIndex < fileCount - 1) {
            newIndex++;
        }
        if (newIndex != m_currentIndex && newIndex >= 0 && newIndex < fileCount) {
            updateSelection(newIndex);
        }
        event->accept();
        return;
    }
    QScrollArea::keyPressEvent(event);
}
void CustomFileListWidget::dragEnterEvent(QDragEnterEvent* event)
{
    // 添加空指针检查
    if (!event || !event->mimeData()) {
        return;
    }
    if (event->mimeData()->hasFormat("application/x-customfileitem-indices")) {
        event->acceptProposedAction();
    } else {
        event->ignore();
    }
}
void CustomFileListWidget::dragMoveEvent(QDragMoveEvent* event)
{
    // 添加空指针检查
    if (!event || !event->mimeData()) {
        return;
    }
    if (event->mimeData()->hasFormat("application/x-customfileitem-indices")) {
        int targetIndex = getDropTargetIndex(event->position().toPoint());
        if (targetIndex != m_dropIndicatorIndex) {
            showDropIndicator(targetIndex);
        }
        event->acceptProposedAction();
    } else {
        event->ignore();
    }
}
void CustomFileListWidget::dropEvent(QDropEvent* event)
{
    // 添加空指针检查
    if (!event || !event->mimeData()) {
        hideDropIndicator();
        return;
    }
    if (event->mimeData()->hasFormat("application/x-customfileitem-indices")) {
        QByteArray indexData = event->mimeData()->data("application/x-customfileitem-indices");
        QDataStream stream(&indexData, QDataStream::ReadOnly);
        QList<int> dragIndices;
        stream >> dragIndices;
        int targetIndex = getDropTargetIndex(event->position().toPoint());
        // 添加更严格的验证
        if (!dragIndices.isEmpty() && targetIndex >= 0 && m_parentBrowser) {
            // 验证拖拽索引的有效性
            bool validIndices = true;
            int fileCount = m_parentBrowser->getFileCount();
            for (int index : dragIndices) {
                if (index < 0 || index >= fileCount) {
                    validIndices = false;
                    break;
                }
            }
            if (validIndices) {
                // 使用拖拽上下文设置目标索引并计算新位置
                m_dragContext->setTargetIndex(targetIndex);
                m_dragContext->calculateNewPositions(fileCount);
                // 获取计算出的新位置
                QList<int> newPositions = m_dragContext->getNewPositions();
                emit itemDragRequested(dragIndices, targetIndex);
                event->acceptProposedAction();
            } else {
                event->ignore();
            }
        } else {
            event->ignore();
        }
    } else {
        event->ignore();
    }
    hideDropIndicator();
}
void CustomFileListWidget::dragLeaveEvent(QDragLeaveEvent* event)
{
    hideDropIndicator();
    QScrollArea::dragLeaveEvent(event);
}
void CustomFileListWidget::onItemClicked(CustomFileItem* item, Qt::KeyboardModifiers modifiers)
{
    // === 虚拟化架构：检查item是否有效 ===
    if (!item || !item->isEnabled() || !item->isVisible()) {
        return;
    }
    
    // 检查item是否在池中
    if (!m_itemPool.contains(item)) {
        return;  // item不在池中（不应该发生）
    }
    
    // 【虚拟化】获取item对应的文件索引
    int index = getFileIndexForItem(item);
    if (index < 0) {
        return;  // item未绑定到文件
    }
    
    // 验证文件索引有效性
    if (!m_parentBrowser || index >= m_parentBrowser->getFileCount()) {
        return;
    }
    if (modifiers & Qt::ControlModifier) {
        // Ctrl+点击：切换选中状态
        toggleItemSelection(index);
    } else if (modifiers & Qt::ShiftModifier && m_currentIndex >= 0) {
        // Shift+点击：范围选择
        selectRange(m_currentIndex, index);
    } else {
        // 普通点击：单选（用户主动点击，发送信号）
        updateSelection(index, true);
    }
}
void CustomFileListWidget::onItemRightClicked(CustomFileItem* item, const QPoint& globalPos)
{
    // === 虚拟化架构：检查item是否有效 ===
    if (!item || !item->isEnabled() || !item->isVisible()) {
        return;
    }
    
    // 检查item是否在池中
    if (!m_itemPool.contains(item)) {
        return;  // item不在池中（不应该发生）
    }
    
    // 【虚拟化】获取item对应的文件索引
    int index = getFileIndexForItem(item);
    if (index < 0) {
        return;  // item未绑定到文件
    }
    
    // 验证文件索引有效性
    if (!m_parentBrowser || index >= m_parentBrowser->getFileCount()) {
        return;
    }
    
    // 如果右键的项目没有被选中，先选中它
    if (!m_selectedIndices.contains(index)) {
        updateSelection(index);
    }
    emit itemRightClicked(index, globalPos);
}
void CustomFileListWidget::onItemDragStarted(CustomFileItem* item, const QPoint& startPos)
{
    Q_UNUSED(startPos)
    // === 虚拟化架构：检查item是否有效 ===
    if (!item || !item->isEnabled() || !item->isVisible()) {
        return;
    }
    
    // 检查item是否在池中
    if (!m_itemPool.contains(item)) {
        return;  // item不在池中（不应该发生）
    }
    
    // 【虚拟化】获取item对应的文件索引
    int dragIndex = getFileIndexForItem(item);
    if (dragIndex < 0) {
        return;  // item未绑定到文件
    }
    
    // 验证文件索引有效性
    if (!m_parentBrowser || dragIndex >= m_parentBrowser->getFileCount()) {
        return;
    }
    // 如果拖拽的项目没有被选中，先选中它
    if (!m_selectedIndices.contains(dragIndex)) {
        if (m_selectedIndices.size() <= 1) {
            updateSelection(dragIndex);
        } else {
            toggleItemSelection(dragIndex);
        }
    } else {
    }
    // 启动拖拽操作
    QList<int> selectedItems = m_selectedIndices.values();
    std::sort(selectedItems.begin(), selectedItems.end());
    startDragOperation(selectedItems);
}
void CustomFileListWidget::clearAllItems()
{
    // === 超级关键：先保存所有items的指针，在清空列表后再删除 ===
    QList<CustomFileItem*> itemsToDelete = m_items;
    
    // 立即清空列表，防止任何访问
    m_items.clear();
    
    // 立即清理布局（在删除items之前）
    QLayoutItem* child;
    while ((child = m_layout->takeAt(0)) != nullptr) {
        // 只删除layout item，不删除widget
        if (child->widget()) {
            // widget会在后面手动删除
        }
        delete child;
    }
    
    // === 阶段1：禁用所有items并处理事件 ===
    for (CustomFileItem* item : itemsToDelete) {
        if (item) {
            // 移除事件过滤器
            item->removeEventFilter(this);
            // 移除所有待处理的事件
            QCoreApplication::removePostedEvents(item);
            // 完全隐藏并禁用
            item->hide();
            item->setEnabled(false);
            item->setAttribute(Qt::WA_TransparentForMouseEvents, true);
            item->blockSignals(true);
            item->setMouseTracking(false);
            item->setAttribute(Qt::WA_Hover, false);
            // 断开所有连接
            disconnect(item, nullptr, nullptr, nullptr);
        }
    }
    
    // === 阶段2：处理所有待处理的事件（确保item不再接收新事件）===
    QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
    QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
    
    // === 阶段3：从父对象分离所有items ===
    for (CustomFileItem* item : itemsToDelete) {
        if (item) {
            // 从parent移除（可能触发事件，但item已完全禁用）
            item->setParent(nullptr);
        }
    }
    
    // === 阶段4：再次处理事件，确保setParent触发的事件被处理 ===
    QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
    
    // === 阶段5：立即删除所有items ===
    for (CustomFileItem* item : itemsToDelete) {
        if (item) {
            delete item;  // 立即删除
        }
    }
    
    // === 阶段6：最后处理删除相关的事件 ===
    QCoreApplication::sendPostedEvents(nullptr, QEvent::DeferredDelete);
    QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
}
void CustomFileListWidget::createItemsFromParentData()
{
    if (!m_parentBrowser) {
        return;
    }
    int fileCount = m_parentBrowser->getFileCount();
    for (int i = 0; i < fileCount; ++i) {
        UnifiedFileInfo fileInfo = m_parentBrowser->getFile(i);
        CustomFileItem* item = new CustomFileItem(fileInfo, this);
        
        // === 关键修复：为新创建的item安装事件过滤器 ===
        item->installEventFilter(this);
        
        // 如果启用了自适应模式，设置初始宽度
        if (m_adaptiveMode) {
            if (m_currentWidth > 0) {
                item->setAdaptiveWidth(m_currentWidth);
            } else {
                // 如果自适应模式启用但m_currentWidth为0，立即计算正确的宽度
                updateItemWidths();
                if (m_currentWidth > 0) {
                    item->setAdaptiveWidth(m_currentWidth);
                }
            }
        }
        m_items.append(item);
        m_layout->addWidget(item, 0, Qt::AlignTop);  // 添加对齐方式，防止拉伸
        connectItemSignals(item);
    }
    // 添加弹性空间，将所有项目推到顶部
    m_layout->addStretch(1);
}
void CustomFileListWidget::connectItemSignals(CustomFileItem* item)
{
    connect(item, &CustomFileItem::clicked, this, &CustomFileListWidget::onItemClicked);
    connect(item, &CustomFileItem::rightClicked, this, &CustomFileListWidget::onItemRightClicked);
    connect(item, &CustomFileItem::dragStartRequested, this, &CustomFileListWidget::onItemDragStarted);
}
int CustomFileListWidget::getItemIndex(const CustomFileItem* item) const
{
    return m_items.indexOf(const_cast<CustomFileItem*>(item));
}
void CustomFileListWidget::startDragOperation(const QList<int>& indices)
{
    if (indices.isEmpty()) {
        return;
    }
    // 检查拖拽状态，避免重复拖拽
    if (m_isDragInProgress) {
        return;
    }
    // 添加父浏览器检查
    if (!m_parentBrowser) {
        return;
    }
    // 验证索引有效性
    int fileCount = m_parentBrowser->getFileCount();
    for (int index : indices) {
        if (index < 0 || index >= fileCount) {
            return;
        }
    }
    
    // 【虚拟化】为被拖拽的项目添加视觉反馈
    for (int index : indices) {
        CustomFileItem* item = getItemForFileIndex(index);
        if (item) {
            // 添加拖拽开始时的视觉反馈
            item->setProperty("isDragging", true);
            item->update();
        }
    }
    
    // 使用拖拽上下文开始拖拽
    m_dragContext->startDrag(indices);
    m_isDragInProgress = true;
    QMimeData* mimeData = createDragMimeData(indices);
    if (!mimeData) {
        m_isDragInProgress = false;
        return;
    }
    QDrag* drag = new QDrag(this);
    drag->setMimeData(mimeData);
    QPixmap dragPixmap = createDragPixmap(indices);
    if (!dragPixmap.isNull()) {
        drag->setPixmap(dragPixmap);
        drag->setHotSpot(QPoint(dragPixmap.width() / 2, dragPixmap.height() / 2));
    }
    Qt::DropAction dropAction = drag->exec(Qt::MoveAction);
    if (dropAction == Qt::MoveAction) {
        m_dragContext->completeDrag();
        // 获取最终的拖拽位置
        QList<int> finalPositions = m_dragContext->getNewPositions();
        // 重置拖拽状态
        m_isDragInProgress = false;
        hideDropIndicator();
        // 注意：不再在这里调用refreshUI，因为connectDragContext中的dragCompleted信号已经处理了
        // 避免重复刷新导致高亮状态被覆盖
    } else {
        m_dragContext->cancelDrag();
        // 重置拖拽状态
        m_isDragInProgress = false;
        hideDropIndicator();
    }
    
    // 【虚拟化】清除拖拽视觉反馈
    for (int index : indices) {
        CustomFileItem* item = getItemForFileIndex(index);
        if (item) {
            item->setProperty("isDragging", false);
            item->update();
        }
    }
}
QMimeData* CustomFileListWidget::createDragMimeData(const QList<int>& indices)
{
    // 验证索引有效性
    if (!m_parentBrowser) {
        return nullptr; // 返回空指针，让调用者处理
    }
    QList<int> validIndices;
    int fileCount = m_parentBrowser->getFileCount();
    for (int index : indices) {
        if (index >= 0 && index < fileCount) {
            validIndices.append(index);
        } else {
        }
    }
    if (validIndices.isEmpty()) {
        return nullptr;
    }
    QMimeData* mimeData = new QMimeData;
    QByteArray indexData;
    QDataStream stream(&indexData, QDataStream::WriteOnly);
    stream << validIndices;
    mimeData->setData("application/x-customfileitem-indices", indexData);
    return mimeData;
}
QPixmap CustomFileListWidget::createDragPixmap(const QList<int>& indices)
{
    if (indices.isEmpty() || !m_parentBrowser) {
        return QPixmap();
    }
    // 验证第一个索引的有效性
    int firstIndex = indices.first();
    if (firstIndex < 0 || firstIndex >= m_parentBrowser->getFileCount()) {
        return QPixmap();
    }
    
    // 根据当前宽度和拖拽文件数量调整尺寸
    int currentWidth = m_adaptiveMode ? m_currentWidth : 300; // 默认宽度
    int baseWidth, baseHeight, cornerRadius;
    
    if (currentWidth < 120) {
        // 极致紧凑模式：最小预览图
        baseWidth = indices.size() == 1 ? 120 : 100;
        baseHeight = indices.size() == 1 ? 30 : 25;
        cornerRadius = 6;
    } else if (currentWidth < 160) {
        // 超紧凑模式：小预览图
        baseWidth = indices.size() == 1 ? 140 : 120;
        baseHeight = indices.size() == 1 ? 35 : 30;
        cornerRadius = 8;
    } else if (currentWidth < 260) {
        // 标准紧凑模式：标准预览图
        baseWidth = indices.size() == 1 ? 180 : 160;
        baseHeight = indices.size() == 1 ? 50 : 45;
        cornerRadius = 10;
    } else {
        // 完整模式：完整预览图
        baseWidth = indices.size() == 1 ? 200 : 180;
        baseHeight = indices.size() == 1 ? 60 : 50;
        cornerRadius = 12;
    }
    
    QPixmap pixmap(baseWidth, baseHeight);
    pixmap.fill(Qt::transparent);
    QPainter painter(&pixmap);
    painter.setRenderHint(QPainter::Antialiasing);
    
    // 绘制阴影效果
    QRect shadowRect(2, 2, baseWidth, baseHeight);
    painter.setBrush(QBrush(QColor(0, 0, 0, 30)));
    painter.setPen(Qt::NoPen);
    painter.drawRoundedRect(shadowRect, cornerRadius, cornerRadius);
    
    // 绘制主背景 - 使用渐变效果
    QLinearGradient gradient(0, 0, 0, baseHeight);
    gradient.setColorAt(0, QColor(0, 122, 255, 240));
    gradient.setColorAt(1, QColor(0, 100, 220, 240));
    
    painter.setBrush(QBrush(gradient));
    painter.setPen(QPen(QColor(255, 255, 255, 150), 1));
    painter.drawRoundedRect(0, 0, baseWidth, baseHeight, cornerRadius, cornerRadius);
    
    // 根据宽度调整图标和文本参数
    int iconSize, iconX, iconY, textX, textWidth, fontSize;
    
    if (currentWidth < 120) {
        // 极致紧凑模式：最小图标和文本
        iconSize = 12;
        iconX = 6;
        iconY = 4;
        textX = 20;
        textWidth = baseWidth - 24;
        fontSize = 9;
    } else if (currentWidth < 160) {
        // 超紧凑模式：小图标和文本
        iconSize = 16;
        iconX = 8;
        iconY = 6;
        textX = 28;
        textWidth = baseWidth - 32;
        fontSize = 10;
    } else if (currentWidth < 260) {
        // 标准紧凑模式：标准图标和文本
        iconSize = 20;
        iconX = 10;
        iconY = 8;
        textX = 36;
        textWidth = baseWidth - 40;
        fontSize = 11;
    } else {
        // 完整模式：完整图标和文本
        iconSize = 24;
        iconX = 12;
        iconY = 8;
        textX = 44;
        textWidth = baseWidth - 48;
        fontSize = 13;
    }
    
    // 绘制文件图标
    if (indices.size() == 1) {
        UnifiedFileInfo fileInfo = m_parentBrowser->getFile(indices[0]);
        QIcon fileIcon = getFileIcon(fileInfo);
        QRect iconRect(iconX, iconY, iconSize, iconSize);
        fileIcon.paint(&painter, iconRect);
    } else {
        // 多文件时显示堆叠图标效果
        int stackSize = iconSize * 0.8;
        QRect iconRect1(iconX, iconY, stackSize, stackSize);
        QRect iconRect2(iconX + 2, iconY + 2, stackSize, stackSize);
        painter.setBrush(QBrush(QColor(255, 255, 255, 180)));
        painter.setPen(QPen(QColor(255, 255, 255, 100), 1));
        painter.drawRoundedRect(iconRect1, 4, 4);
        painter.drawRoundedRect(iconRect2, 4, 4);
    }
    
    // 绘制文本
    painter.setPen(Qt::white);
    QFont font = this->font();
    font.setPixelSize(fontSize);
    font.setBold(true);
    painter.setFont(font);
    
    QString displayText;
    if (indices.size() == 1) {
        UnifiedFileInfo fileInfo = m_parentBrowser->getFile(indices[0]);
        displayText = fileInfo.fileName;
    } else {
        displayText = tr("%1个文件").arg(indices.size());
    }
    
    QRect textRect(textX, iconY, textWidth, baseHeight - iconY * 2);
    QFontMetrics fm(font);
    QString elidedText = fm.elidedText(displayText, Qt::ElideMiddle, textRect.width());
    painter.drawText(textRect, Qt::AlignLeft | Qt::AlignVCenter, elidedText);
    
    return pixmap;
}

QIcon CustomFileListWidget::getFileIcon(const UnifiedFileInfo& fileInfo) const
{
    // 根据文件类型返回相应的图标
    QString ext = QFileInfo(fileInfo.filePath).suffix().toLower();
    if (ext == "pdf") return QIcon(":/icons/pdf_file.png");
    if (ext == "png") return QIcon(":/icons/png_file.png");
    if (ext == "jpg" || ext == "jpeg") return QIcon(":/icons/jpg_file.png");
    if (ext == "gif") return QIcon(":/icons/gif_file.png");
    if (ext == "bmp") return QIcon(":/icons/bmp_file.png");
    if (ext == "tiff" || ext == "tif") return QIcon(":/icons/tiff_file.png");
    if (ext == "webp") return QIcon(":/icons/webp_file.png");
    // 回退到通用图片图标
    return QIcon(":/icons/image_file.png");
}

int CustomFileListWidget::getDropTargetIndex(const QPoint& pos) const
{
    // 添加空指针检查
    if (!m_contentWidget) {
        return 0;
    }
    QPoint contentPos = m_contentWidget->mapFromParent(pos);
    // 添加边界检查
    if (m_items.isEmpty()) {
        return 0;
    }
    for (int i = 0; i < m_items.size(); ++i) {
        CustomFileItem* item = m_items[i];
        // 添加空指针检查
        if (!item) {
            continue;
        }
        QRect itemRect = item->geometry();
        // 添加几何体有效性检查
        if (itemRect.isEmpty()) {
            continue;
        }
        if (contentPos.y() < itemRect.center().y()) {
            return i;
        }
    }
    int result = m_items.size();
    return result;
}
void CustomFileListWidget::showDropIndicator(int targetIndex)
{
    m_dropIndicatorIndex = targetIndex;
    update();
}
void CustomFileListWidget::hideDropIndicator()
{
    if (m_dropIndicatorIndex != -1) {
        m_dropIndicatorIndex = -1;
        update();
    }
}

void CustomFileListWidget::paintEvent(QPaintEvent* event)
{
    QScrollArea::paintEvent(event);
    
    // 绘制拖拽指示器
    if (m_dropIndicatorIndex >= 0 && m_dropIndicatorIndex < m_items.size()) {
        QPainter painter(viewport());
        painter.setRenderHint(QPainter::Antialiasing);
        
        // 计算指示器位置
        CustomFileItem* targetItem = m_items[m_dropIndicatorIndex];
        if (targetItem) {
            QRect itemRect = targetItem->geometry();
            QPoint contentPos = m_contentWidget->mapToParent(QPoint(0, 0));
            
            // 根据当前宽度计算响应式指示器参数
            int currentWidth = m_adaptiveMode ? m_currentWidth : width();
            
            // 指示器位置：在目标项目上方
            int indicatorY = itemRect.top() + contentPos.y() - 2;
            int indicatorX, indicatorWidth, indicatorHeight;
            
            // 根据宽度调整指示器样式
            if (currentWidth < 120) {
                // 极致紧凑模式：最小指示器
                indicatorX = contentPos.x() + 4;
                indicatorWidth = currentWidth - 8;
                indicatorHeight = 2;
            } else if (currentWidth < 160) {
                // 超紧凑模式：小指示器
                indicatorX = contentPos.x() + 6;
                indicatorWidth = currentWidth - 12;
                indicatorHeight = 2;
            } else if (currentWidth < 260) {
                // 标准紧凑模式：标准指示器
                indicatorX = contentPos.x() + 8;
                indicatorWidth = currentWidth - 16;
                indicatorHeight = 3;
            } else {
                // 完整模式：完整指示器
                indicatorX = contentPos.x() + 12;
                indicatorWidth = currentWidth - 24;
                indicatorHeight = 4;
            }
            
            // 绘制指示器 - 使用Apple风格的蓝色线条
            QRect indicatorRect(indicatorX, indicatorY, indicatorWidth, indicatorHeight);
            
            // 根据宽度调整渐变效果
            QLinearGradient gradient(indicatorRect.left(), 0, indicatorRect.right(), 0);
            if (currentWidth < 160) {
                // 紧凑模式：简单渐变
                gradient.setColorAt(0, QColor(0, 122, 255, 0));
                gradient.setColorAt(0.5, QColor(0, 122, 255, 200));
                gradient.setColorAt(1, QColor(0, 122, 255, 0));
            } else {
                // 标准模式：完整渐变
                gradient.setColorAt(0, QColor(0, 122, 255, 0));
                gradient.setColorAt(0.5, QColor(0, 122, 255, 255));
                gradient.setColorAt(1, QColor(0, 122, 255, 0));
            }
            
            painter.setBrush(QBrush(gradient));
            painter.setPen(Qt::NoPen);
            painter.drawRoundedRect(indicatorRect, 2, 2);
            
            // 根据宽度调整发光效果
            if (currentWidth >= 160) {
                painter.setPen(QPen(QColor(0, 122, 255, 100), 1));
                painter.drawRoundedRect(indicatorRect.adjusted(0, 0, 0, 0), 2, 2);
            }
        }
    }
}
void CustomFileListWidget::toggleItemSelection(int index)
{
    if (!m_parentBrowser || index < 0 || index >= m_parentBrowser->getFileCount()) {
        return;
    }
    if (m_selectedIndices.contains(index)) {
        // 取消选中
        m_selectedIndices.remove(index);
        
        // 【虚拟化】更新UI
        CustomFileItem* item = getItemForFileIndex(index);
        if (item) {
            item->setSelected(false);
        }
        
        if (m_currentIndex == index) {
            if (!m_selectedIndices.isEmpty()) {
                m_currentIndex = *m_selectedIndices.begin();
            } else {
                m_currentIndex = -1;
            }
        }
    } else {
        // 添加选中
        m_selectedIndices.insert(index);
        
        // 【虚拟化】更新UI
        CustomFileItem* item = getItemForFileIndex(index);
        if (item) {
            item->setSelected(true);
        }
        
        m_currentIndex = index;
        // 用户主动操作，发送信号
        emit itemClicked(index);
    }
    emit selectionChanged(m_selectedIndices.values());
}
void CustomFileListWidget::selectRange(int start, int end)
{
    if (!m_parentBrowser) {
        return;
    }
    int fileCount = m_parentBrowser->getFileCount();
    if (start < 0 || end < 0 || start >= fileCount || end >= fileCount) {
        return;
    }
    // 保存用户最后点击的索引（用于设置m_currentIndex）
    int userClickedIndex = end;
    // 计算选择范围，但不交换start和end，保持shift选择的逻辑连续性
    int rangeStart, rangeEnd;
    if (start <= end) {
        rangeStart = start;
        rangeEnd = end;
    } else {
        rangeStart = end;
        rangeEnd = start;
    }
    // Shift选择模式：在原有选择基础上添加或减少范围
    // 检查当前shift选择是扩展还是收缩
    static int lastShiftStart = -1;
    static int lastShiftEnd = -1;
    bool isExpanding = true;
    if (lastShiftStart != -1 && lastShiftEnd != -1) {
        // 判断此次操作是扩展还是收缩选择
        int lastRangeStart = qMin(lastShiftStart, lastShiftEnd);
        int lastRangeEnd = qMax(lastShiftStart, lastShiftEnd);
        // 如果新范围在旧范围内，则是收缩操作
        if (rangeStart >= lastRangeStart && rangeEnd <= lastRangeEnd) {
            isExpanding = false;
        }
    }
    if (isExpanding) {
        // 扩展选择：在原有选择基础上添加新范围
        // 选中范围内的所有项目
        for (int i = rangeStart; i <= rangeEnd; ++i) {
            if (!m_selectedIndices.contains(i)) {
                m_selectedIndices.insert(i);
                if (i < m_items.size() && m_items[i]) {
                    m_items[i]->setSelected(true);
                }
            }
        }
    } else {
        // 收缩选择：重新选择当前范围
        // 清除之前的选择
        clearSelection();
        // 选中范围内的所有项目
        for (int i = rangeStart; i <= rangeEnd; ++i) {
            m_selectedIndices.insert(i);
            if (i < m_items.size() && m_items[i]) {
                m_items[i]->setSelected(true);
            }
        }
    }
    // 设置当前索引为用户最后点击的索引
    m_currentIndex = userClickedIndex;
    // 记录本次shift选择范围
    lastShiftStart = start;
    lastShiftEnd = end;
    emit itemClicked(userClickedIndex);
    emit selectionChanged(m_selectedIndices.values());
}

// resizeEvent已移至虚拟化实现部分（文件末尾）

bool CustomFileListWidget::eventFilter(QObject* watched, QEvent* event)
{
    // === 超级关键：检查watched对象是否已在删除列表中 ===
    if (event && watched) {
        CustomFileItem* item = qobject_cast<CustomFileItem*>(watched);
        if (item) {
            // 检查item是否已从m_items移除（说明正在删除）
            if (!m_items.contains(item)) {
                event->ignore();
                return true;  // 拦截！item正在被删除
            }
            
            // 检查item的状态
            if (!item->isEnabled() || !item->isVisible() || 
                item->testAttribute(Qt::WA_TransparentForMouseEvents)) {
                event->ignore();
                return true;  // 拦截！item已被禁用
            }
        }
    }
    
    // === 关键修复：在刷新期间阻止所有鼠标事件 ===
    if (m_isRefreshing && event) {
        switch (event->type()) {
            case QEvent::MouseButtonPress:
            case QEvent::MouseButtonRelease:
            case QEvent::MouseMove:
            case QEvent::MouseButtonDblClick:
            case QEvent::Enter:
            case QEvent::Leave:
            case QEvent::HoverEnter:
            case QEvent::HoverLeave:
            case QEvent::HoverMove:
                event->ignore();
                return true;  // 拦截事件，不继续传递
            default:
                break;
        }
    }
    
    return QScrollArea::eventFilter(watched, event);
}
// === Martin Fowler重构：Extract Method - 拖拽后选择状态恢复 ===
void CustomFileListWidget::restoreSelectionAfterDrag(const QList<int>& draggedNewPositions)
{
    // 1. 清除所有UI项的选中状态
    for (int i = 0; i < m_items.size(); ++i) {
        if (m_items[i]) {
            m_items[i]->setSelected(false);
        }
    }
    // 2. 重置选择状态
    m_selectedIndices.clear();
    m_currentIndex = -1;
    // 3. 高亮被拖拽文件的新位置（按draggedNewPositions中指定的位置）
    for (int newPos : draggedNewPositions) {
        if (newPos >= 0 && newPos < m_parentBrowser->getFileCount() && newPos < m_items.size()) {
            if (m_items[newPos]) {
                m_selectedIndices.insert(newPos);
                m_items[newPos]->setSelected(true);
            } else {
            }
        } else {
        }
    }
    // 4. 设置当前索引为第一个拖拽位置
    if (!m_selectedIndices.isEmpty()) {
        // 找到拖拽新位置中最小的索引作为当前索引
        int minIndex = *std::min_element(m_selectedIndices.begin(), m_selectedIndices.end());
        m_currentIndex = minIndex;
    } else {
    }
    // 5. 发送信号通知选择状态变化
    emit selectionChanged(m_selectedIndices.values());
}
// === Martin Fowler重构：Extract Method - 正常状态恢复（修复多选逻辑） ===
void CustomFileListWidget::restoreSelectionAfterRefresh(int savedCurrentIndex, const QSet<int>& savedSelectedIndices)
{
    // === 关键修复：先恢复多选状态，再设置当前索引，避免clearSelection()清除多选 ===
    if (savedCurrentIndex >= 0 && savedCurrentIndex < m_parentBrowser->getFileCount()) {
        // 1. 先恢复所有多选状态（避免被updateSelection清除）
        for (int index : savedSelectedIndices) {
            if (index >= 0 && index < m_parentBrowser->getFileCount()) {
                m_selectedIndices.insert(index);
                if (index < m_items.size() && m_items[index]) {
                    m_items[index]->setSelected(true);
                }
            }
        }
        // 2. 设置当前索引（不清除多选状态）
        m_currentIndex = savedCurrentIndex;
        // 3. 确保当前索引对应的UI项也被选中
        if (savedCurrentIndex < m_items.size() && m_items[savedCurrentIndex]) {
            m_items[savedCurrentIndex]->setSelected(true);
        }
        // 4. 发送信号通知选择状态变化（不通过updateSelection，避免重复清理）
        emit selectionChanged(m_selectedIndices.values());
    } else {
        if (m_parentBrowser->getFileCount() > 0) {
            // 保存的选中文件不存在了，选择第一个
            updateSelection(0, false);
        }
    }
}

// ========================================================================
// === 虚拟化列表核心实现（Item池复用，零崩溃架构）===
// ========================================================================

void CustomFileListWidget::initializeItemPool()
{
    qDebug() << "[虚拟化] 开始初始化item池...";
    
    // 计算初始池大小
    int initialSize = m_virtualManager->getOptimalPoolSize(
        viewport()->height(), 
        CustomFileItem::ITEM_HEIGHT
    );
    
    qDebug() << "[虚拟化] 初始池大小:" << initialSize 
             << "（窗口高度:" << viewport()->height() << "）";
    
    // 创建item池
    for (int i = 0; i < initialSize; ++i) {
        CustomFileItem* item = new CustomFileItem(m_contentWidget);
        item->setAdaptiveWidth(m_currentWidth);
        item->hide();  // 初始隐藏
        
        // 连接信号
        connectItemSignals(item);
        
        // 【关键】添加到布局，设置不拉伸且顶部对齐
        m_layout->addWidget(item, 0, Qt::AlignTop);  // 0=不拉伸，顶部对齐
        m_itemPool.append(item);
    }
    
    // 【关键】添加弹性空间，把所有item推到顶部，防止布局系统分配额外空间
    m_layout->addStretch(1);
    
    qDebug() << "[虚拟化] Item池初始化完成，共" << m_itemPool.size() << "个item";
}

void CustomFileListWidget::expandItemPool(int targetSize)
{
    int currentSize = m_itemPool.size();
    
    if (targetSize <= currentSize) {
        qDebug() << "[虚拟化] 池大小已满足，无需扩展（当前:" << currentSize 
                 << " 目标:" << targetSize << "）";
        return;
    }
    
    qDebug() << "[虚拟化] 扩展item池：" << currentSize << " → " << targetSize;
    
    // 【关键】先移除stretch（如果存在）
    int stretchIndex = m_layout->count() - 1;
    if (stretchIndex >= 0) {
        QLayoutItem* lastItem = m_layout->itemAt(stretchIndex);
        if (lastItem && lastItem->spacerItem()) {
            m_layout->takeAt(stretchIndex);
            delete lastItem;
        }
    }
    
    // 创建新的item
    for (int i = currentSize; i < targetSize; ++i) {
        CustomFileItem* item = new CustomFileItem(m_contentWidget);
        item->setAdaptiveWidth(m_currentWidth);
        item->hide();  // 初始隐藏
        
        // 连接信号
        connectItemSignals(item);
        
        // 【关键】添加到布局，设置不拉伸且顶部对齐
        m_layout->insertWidget(i, item, 0, Qt::AlignTop);  // 0=不拉伸
        m_itemPool.append(item);
    }
    
    // 【关键】重新添加stretch到末尾
    m_layout->addStretch(1);
    
    // 更新虚拟化管理器
    m_virtualManager->adjustPoolSize(targetSize);
    
    qDebug() << "[虚拟化] Item池扩展完成，新大小:" << m_itemPool.size();
}

void CustomFileListWidget::updateItemPool()
{
    // 根据窗口高度计算最优池大小
    int optimalSize = m_virtualManager->getOptimalPoolSize(
        viewport()->height(), 
        CustomFileItem::ITEM_HEIGHT
    );
    
    // 如果需要扩展
    if (optimalSize > m_itemPool.size()) {
        expandItemPool(optimalSize);
    }
}

void CustomFileListWidget::bindItemToFile(CustomFileItem* item, int fileIndex)
{
    if (!item || !m_parentBrowser) {
        return;
    }
    
    if (fileIndex < 0 || fileIndex >= m_parentBrowser->getFileCount()) {
        // 无效索引，隐藏item
        item->hide();
        m_virtualManager->unbindItem(item);
        return;
    }
    
    // 获取文件数据
    UnifiedFileInfo fileInfo = m_parentBrowser->getFile(fileIndex);
    
    // 更新item数据
    item->setFileInfo(fileInfo);
    
    // 更新选择状态
    bool isSelected = m_selectedIndices.contains(fileIndex);
    item->setSelected(isSelected);
    
    // 显示item
    item->show();
    
    // 在虚拟化管理器中注册绑定
    m_virtualManager->bindItemToFile(item, fileIndex);
}

void CustomFileListWidget::unbindItem(CustomFileItem* item)
{
    if (!item) {
        return;
    }
    
    // 隐藏item
    item->hide();
    
    // 从虚拟化管理器中解除绑定
    m_virtualManager->unbindItem(item);
}

CustomFileItem* CustomFileListWidget::getItemForFileIndex(int fileIndex) const
{
    return m_virtualManager->getItemForFileIndex(fileIndex);
}

int CustomFileListWidget::getFileIndexForItem(const CustomFileItem* item) const
{
    return m_virtualManager->getFileIndexForItem(const_cast<CustomFileItem*>(item));
}

void CustomFileListWidget::rebindVisibleItems()
{
    if (!m_parentBrowser) {
        return;
    }
    
    int fileCount = m_parentBrowser->getFileCount();
    
    // 计算可见范围
    int scrollOffset = verticalScrollBar()->value();
    int windowHeight = viewport()->height();
    
    VirtualListManager::VisibleRange range = m_virtualManager->calculateVisibleRange(
        scrollOffset, 
        windowHeight, 
        CustomFileItem::ITEM_HEIGHT, 
        fileCount
    );
    
    qDebug() << "[虚拟化] 重新绑定可见区域：scrollOffset=" << scrollOffset 
             << " 可见范围[" << range.startIndex << "," << range.endIndex << "]"
             << " 缓冲范围[" << range.bufferStart << "," << range.bufferEnd << "]";
    
    // 计算需要显示的文件数量（包括缓冲区）
    int itemsToShow = range.bufferEnd - range.bufferStart;
    
    // 确保池大小足够
    if (itemsToShow > m_itemPool.size()) {
        expandItemPool(qMin(itemsToShow, VirtualListManager::MAX_POOL_SIZE));
    }
    
    // 绑定item到文件（包括缓冲区）
    int poolIndex = 0;
    for (int fileIndex = range.bufferStart; fileIndex < range.bufferEnd && poolIndex < m_itemPool.size(); ++fileIndex, ++poolIndex) {
        bindItemToFile(m_itemPool[poolIndex], fileIndex);
    }
    
    // 隐藏多余的item
    for (int i = poolIndex; i < m_itemPool.size(); ++i) {
        m_itemPool[i]->hide();
        m_virtualManager->unbindItem(m_itemPool[i]);
    }
    
    qDebug() << "[虚拟化] 可见item数量:" << poolIndex 
             << " 总文件数:" << fileCount 
             << " 池大小:" << m_itemPool.size();
}

void CustomFileListWidget::rebindAllItems()
{
    if (!m_parentBrowser) {
        return;
    }
    
    int fileCount = m_parentBrowser->getFileCount();
    
    qDebug() << "[虚拟化] 重新绑定所有item，文件数:" << fileCount 
             << " 池大小:" << m_itemPool.size();
    
    // 简单版本：直接显示前N个文件（N = min(fileCount, poolSize)）
    int itemsToShow = qMin(fileCount, m_itemPool.size());
    
    // === 关键：同步m_items以保持兼容性 ===
    m_items.clear();
    
    // 绑定item到文件
    for (int i = 0; i < itemsToShow; ++i) {
        bindItemToFile(m_itemPool[i], i);
        m_items.append(m_itemPool[i]);  // 同步到m_items
    }
    
    // 隐藏多余的item
    for (int i = itemsToShow; i < m_itemPool.size(); ++i) {
        m_itemPool[i]->hide();
        m_virtualManager->unbindItem(m_itemPool[i]);
    }
    
    qDebug() << "[虚拟化] 绑定完成，显示" << itemsToShow << "个item，m_items同步完成";
}

void CustomFileListWidget::scrollContentsBy(int dx, int dy)
{
    // 调用父类实现（实际滚动）
    QScrollArea::scrollContentsBy(dx, dy);
    
    // 【关键】滚动后动态重新绑定可见item
    rebindVisibleItems();
}

void CustomFileListWidget::resizeEvent(QResizeEvent* event)
{
    QScrollArea::resizeEvent(event);
    
    // 【关键】窗口resize时更新池大小
    updateItemPool();
    
    // 更新item宽度
    if (m_adaptiveMode) {
        m_currentWidth = viewport()->width();
        for (CustomFileItem* item : m_itemPool) {
            if (item) {
                item->setAdaptiveWidth(m_currentWidth);
            }
        }
    }
    
    // 重新绑定可见item
    rebindVisibleItems();
}

// === 虚拟化调试接口实现 ===

int CustomFileListWidget::getPoolSize() const
{
    return m_itemPool.size();
}

int CustomFileListWidget::getBoundItemCount() const
{
    return m_virtualManager->getBoundItemCount();
}

QList<int> CustomFileListWidget::getVisibleFileIndices() const
{
    return m_virtualManager->getBoundFileIndices();
}